package service;

import model.Class; // 导入Class模型类
import model.User; // 导入User模型类
import utils.DatabaseUtil; // 导入数据库工具类
import java.sql.*; // 导入SQL相关包
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import javax.swing.JOptionPane; // 导入JOptionPane用于弹出对话框

public class ClassService {

    /**
     * 获取所有班级的详细信息，包括班级名称、年级、教师ID、教师姓名、专业代码、专业名称、学生人数和创建时间
     * @return 所有班级的列表
     */
    public List<Class> getAllClasses() {
        List<Class> classes = new ArrayList<>(); // 创建一个ArrayList来存储班级信息
        // SQL查询语句，用于从classes表中获取所有班级信息，并左连接users表和majors表获取教师姓名和专业名称
        String sql = "SELECT c.*, u.name as teacher_name, m.major_name, " +
                "(SELECT COUNT(*) FROM students s WHERE s.class_id = c.id) as student_count " +
                "FROM classes c " +
                "LEFT JOIN users u ON c.teacher_id = u.id " +
                "LEFT JOIN majors m ON c.major_code = m.major_code " +
                "ORDER BY c.class_name"; // 按班级名称排序

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            ResultSet rs = pstmt.executeQuery(); // 执行查询并获取结果集
            while (rs.next()) { // 遍历结果集中的每一行
                Class cls = new Class(); // 创建一个新的Class对象
                // 设置Class对象的各个属性
                cls.setId(rs.getInt("id")); // 设置班级ID
                cls.setClassName(rs.getString("class_name")); // 设置班级名称
                cls.setGradeYear(rs.getInt("grade_year")); // 设置年级
                cls.setTeacherId(rs.getInt("teacher_id")); // 设置教师ID
                cls.setTeacherName(rs.getString("teacher_name")); // 设置教师姓名
                cls.setMajorCode(rs.getString("major_code")); // 设置专业代码
                cls.setMajorName(rs.getString("major_name")); // 设置专业名称
                cls.setStudentCount(rs.getInt("student_count")); // 设置学生人数
                cls.setCreatedAt(rs.getTimestamp("created_at")); // 设置创建时间
                classes.add(cls); // 将Class对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return classes; // 返回班级列表
    }

    /**
     * 创建一个新班级
     * @param className 班级名称
     * @param gradeYear 年级
     * @param teacherId 教师ID
     * @param majorCode 专业代码
     * @return 如果成功创建，则返回true；否则返回false
     */
    public boolean createClass(String className, int gradeYear, int teacherId, String majorCode) {
        // SQL插入语句，用于向classes表中插入新的班级信息
        String sql = "INSERT INTO classes (class_name, grade_year, teacher_id, major_code, created_at) " +
                "VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { // 创建PreparedStatement对象执行SQL插入

            // 设置插入语句中的参数
            pstmt.setString(1, className); // 设置班级名称
            pstmt.setInt(2, gradeYear); // 设置年级
            pstmt.setInt(3, teacherId); // 设置教师ID
            pstmt.setString(4, majorCode); // 设置专业代码

            if (pstmt.executeUpdate() > 0) { // 执行插入操作，如果影响行数大于0，则表示插入成功
                return true;
            }
            return false; // 插入失败返回false
        } catch (SQLException e) { // 捕获SQL异常
            if (e.getErrorCode() == 1062) { // 如果错误代码为1062，表示班级名称已存在
                JOptionPane.showMessageDialog(null, "班级名称已存在！"); // 弹出对话框提示用户
            }
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 插入失败返回false
        }
    }

    /**
     * 更新班级信息
     * @param classId 班级ID
     * @param className 班级名称
     * @param gradeYear 年级
     * @param teacherId 教师ID
     * @param majorCode 专业代码
     * @return 如果成功更新，则返回true；否则返回false
     */
    public boolean updateClass(int classId, String className, int gradeYear,
                               int teacherId, String majorCode) {
        // SQL更新语句，用于更新classes表中的班级信息
        String sql = "UPDATE classes SET class_name = ?, grade_year = ?, " +
                "teacher_id = ?, major_code = ? WHERE id = ?";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL更新

            // 设置更新语句中的参数
            pstmt.setString(1, className); // 设置班级名称
            pstmt.setInt(2, gradeYear); // 设置年级
            pstmt.setInt(3, teacherId); // 设置教师ID
            pstmt.setString(4, majorCode); // 设置专业代码
            pstmt.setInt(5, classId); // 设置班级ID以指定要更新的班级

            return pstmt.executeUpdate() > 0; // 执行更新操作，如果影响行数大于0，则表示更新成功，返回true
        } catch (SQLException e) { // 捕获SQL异常
            if (e.getErrorCode() == 1062) { // 如果错误代码为1062，表示班级名称已存在
                JOptionPane.showMessageDialog(null, "班级名称已存在！"); // 弹出对话框提示用户
            }
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 更新失败返回false
        }
    }

    /**
     * 删除指定的班级
     * @param classId 要删除的班级ID
     * @return 如果成功删除，则返回true；否则返回false
     */
    public boolean deleteClass(int classId) {
        // SQL删除语句，用于从classes表中删除指定的班级
        String sql = "DELETE FROM classes WHERE id = ?";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL删除

            pstmt.setInt(1, classId); // 设置班级ID以指定要删除的班级
            return pstmt.executeUpdate() > 0; // 执行删除操作，如果影响行数大于0，则表示删除成功，返回true
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 删除失败返回false
        }
    }

    /**
     * 获取所有教师的信息
     * @return 所有教师的列表
     */
    public List<User> getAllTeachers() {
        List<User> teachers = new ArrayList<>(); // 创建一个ArrayList来存储教师信息
        // SQL查询语句，用于从users表中获取所有角色为'TEACHER'的用户信息
        String sql = "SELECT id, name FROM users WHERE role = 'TEACHER'";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            ResultSet rs = pstmt.executeQuery(); // 执行查询并获取结果集
            while (rs.next()) { // 遍历结果集中的每一行
                User teacher = new User(); // 创建一个新的User对象
                // 设置User对象的各个属性
                teacher.setId(rs.getInt("id")); // 设置教师ID
                teacher.setName(rs.getString("name")); // 设置教师姓名
                teachers.add(teacher); // 将User对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return teachers; // 返回教师列表
    }

    /**
     * 检查指定的教师是否是任何班级的班主任
     * @param teacherId 要检查的教师ID
     * @return 如果该教师是班主任，则返回true；否则返回false
     */
    public boolean isHeadTeacher(int teacherId) {
        // SQL查询语句，用于检查classes表中是否存在指定教师ID的记录
        String sql = "SELECT 1 FROM classes WHERE teacher_id = ?";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement stmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            stmt.setInt(1, teacherId); // 设置教师ID以指定要检查的教师
            ResultSet rs = stmt.executeQuery(); // 执行查询并获取结果集
            return rs.next(); // 如果结果集不为空，则表示该教师是班主任，返回true
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 检查失败返回false
        }
    }

    /**
     * 获取指定教师所管理的所有班级
     * @param teacherId 教师ID
     * @return 该教师管理的所有班级列表
     */
    public List<Class> getTeacherClasses(int teacherId) {
        List<Class> classes = new ArrayList<>(); // 创建一个ArrayList来存储班级信息
        // SQL查询语句，用于从classes表中获取指定教师ID所管理的所有班级信息
        String sql = "SELECT * FROM classes WHERE teacher_id = ?";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            pstmt.setInt(1, teacherId); // 设置教师ID以指定要查询的教师
            ResultSet rs = pstmt.executeQuery(); // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Class cls = new Class(); // 创建一个新的Class对象
                // 设置Class对象的各个属性
                cls.setId(rs.getInt("id")); // 设置班级ID
                cls.setClassName(rs.getString("class_name")); // 设置班级名称
                cls.setGradeYear(rs.getInt("grade_year")); // 设置年级
                cls.setTeacherId(rs.getInt("teacher_id")); // 设置教师ID
                cls.setCreatedAt(rs.getTimestamp("created_at")); // 设置创建时间
                classes.add(cls); // 将Class对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return classes; // 返回班级列表
    }

    /**
     * 根据班级ID获取班级信息
     * @param classId 班级ID
     * @return 对应的Class对象，如果未找到则返回null
     */
    public Class getClassById(int classId) {
        // SQL查询语句，用于从classes表中根据班级ID获取班级信息
        String sql = "SELECT * FROM classes WHERE id = ?";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement stmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            stmt.setInt(1, classId); // 设置班级ID以指定要查询的班级
            ResultSet rs = stmt.executeQuery(); // 执行查询并获取结果集

            if (rs.next()) { // 如果结果集中有记录
                Class cls = new Class(); // 创建一个新的Class对象
                // 设置Class对象的各个属性
                cls.setId(rs.getInt("id")); // 设置班级ID
                cls.setClassName(rs.getString("class_name")); // 设置班级名称
                cls.setGradeYear(rs.getInt("grade_year")); // 设置年级
                cls.setTeacherId(rs.getInt("teacher_id")); // 设置教师ID
                cls.setMajorCode(rs.getString("major_code")); // 设置专业代码
                cls.setCreatedAt(rs.getDate("created_at")); // 设置创建时间
                return cls; // 返回Class对象
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return null; // 未找到班级返回null
    }

    /**
     * 根据专业代码获取所有班级
     * @param majorCode 专业代码
     * @return 对应专业的所有班级列表
     */
    public List<Class> getClassesByMajor(String majorCode) {
        List<Class> classes = new ArrayList<>(); // 创建一个ArrayList来存储班级信息
        // SQL查询语句，用于从classes表中根据专业代码获取所有班级信息，并按班级名称排序
        String sql = "SELECT * FROM classes WHERE major_code = ? ORDER BY class_name";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            pstmt.setString(1, majorCode); // 设置专业代码以指定要查询的专业
            ResultSet rs = pstmt.executeQuery(); // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Class cls = new Class(); // 创建一个新的Class对象
                // 设置Class对象的各个属性
                cls.setId(rs.getInt("id")); // 设置班级ID
                cls.setClassName(rs.getString("class_name")); // 设置班级名称
                cls.setGradeYear(rs.getInt("grade_year")); // 设置年级
                cls.setTeacherId(rs.getInt("teacher_id")); // 设置教师ID
                cls.setMajorCode(rs.getString("major_code")); // 设置专业代码
                cls.setCreatedAt(rs.getTimestamp("created_at")); // 设置创建时间
                classes.add(cls); // 将Class对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return classes; // 返回班级列表
    }

    /**
     * 分配教师到指定班级的指定课程
     * @param teacherId 教师ID
     * @param classId 班级ID
     * @param subjectId 课程ID
     * @return 如果分配成功，则返回true；否则返回false
     */
    public boolean assignTeacherToSubject(int teacherId, int classId, int subjectId) {
        // SQL插入语句，用于向subject_teachers表中插入新的教师-班级-课程关联记录
        String sql = "INSERT INTO subject_teachers (teacher_id, class_id, subject_id) VALUES (?, ?, ?)";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL插入

            // 设置插入语句中的参数
            pstmt.setInt(1, teacherId); // 设置教师ID
            pstmt.setInt(2, classId); // 设置班级ID
            pstmt.setInt(3, subjectId); // 设置课程ID

            return pstmt.executeUpdate() > 0; // 执行插入操作，如果影响行数大于0，则表示分配成功，返回true
        } catch (SQLException e) { // 捕获SQL异常
            if (e.getErrorCode() == 1062) { // 如果错误代码为1062，表示该教师已分配此课程
                JOptionPane.showMessageDialog(null, "该教师已分配此课程！"); // 弹出对话框提示用户
            }
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 分配失败返回false
        }
    }

    /**
     * 移除教师从指定班级的指定课程
     * @param teacherId 教师ID
     * @param classId 班级ID
     * @param subjectId 课程ID
     * @return 如果移除成功，则返回true；否则返回false
     */
    public boolean removeTeacherFromSubject(int teacherId, int classId, int subjectId) {
        // SQL删除语句，用于从subject_teachers表中删除指定教师-班级-课程关联记录
        String sql = "DELETE FROM subject_teachers WHERE teacher_id = ? AND class_id = ? AND subject_id = ?";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL删除

            // 设置删除语句中的参数
            pstmt.setInt(1, teacherId); // 设置教师ID
            pstmt.setInt(2, classId); // 设置班级ID
            pstmt.setInt(3, subjectId); // 设置课程ID

            return pstmt.executeUpdate() > 0; // 执行删除操作，如果影响行数大于0，则表示移除成功，返回true
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 移除失败返回false
        }
    }

    /**
     * 根据班级ID获取该班级的所有课程及其教师信息
     * @param classId 班级ID
     * @return 该班级的所有课程及其教师信息的列表
     */
    public List<Map<String, Object>> getClassSubjects(int classId) {
        List<Map<String, Object>> subjects = new ArrayList<>(); // 创建一个ArrayList来存储课程及其教师信息
        // SQL查询语句，用于从subjects表中获取指定班级的所有课程及其教师信息
        String sql = "SELECT s.id as subject_id, s.subject_name, " +
                "u.name as teacher_name " +
                "FROM subjects s " +
                "LEFT JOIN subject_teachers st ON s.id = st.subject_id AND st.class_id = ? " +
                "LEFT JOIN users u ON st.teacher_id = u.id " +
                "WHERE s.major_code = (SELECT major_code FROM classes WHERE id = ?)";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            pstmt.setInt(1, classId); // 设置班级ID以指定要查询的班级
            pstmt.setInt(2, classId); // 设置班级ID再次指定要查询的班级
            ResultSet rs = pstmt.executeQuery(); // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Map<String, Object> subject = new HashMap<>(); // 创建一个新的HashMap来存储课程及其教师信息
                // 设置课程及其教师信息的各个属性
                subject.put("subjectId", rs.getInt("subject_id")); // 设置课程ID
                subject.put("subjectName", rs.getString("subject_name")); // 设置课程名称
                subject.put("teacherName", rs.getString("teacher_name")); // 设置教师姓名
                subjects.add(subject); // 将HashMap对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return subjects; // 返回课程及其教师信息列表
    }

    /**
     * 获取所有班级的信息，用于组合框
     * @return 所有班级的ID和名称列表
     */
    public List<Map<String, Object>> getAllClassesForCombo() {
        List<Map<String, Object>> classes = new ArrayList<>(); // 创建一个ArrayList来存储班级ID和名称
        // SQL查询语句，用于从classes表中获取所有班级的ID和名称，并按班级名称排序
        String sql = "SELECT id, class_name FROM classes ORDER BY class_name";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             Statement stmt = conn.createStatement(); // 创建Statement对象执行SQL查询
             ResultSet rs = stmt.executeQuery(sql)) { // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Map<String, Object> cls = new HashMap<>(); // 创建一个新的HashMap来存储班级ID和名称
                // 设置HashMap对象的各个属性
                cls.put("id", rs.getInt("id")); // 设置班级ID
                cls.put("className", rs.getString("class_name")); // 设置班级名称
                classes.add(cls); // 将HashMap对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return classes; // 返回班级ID和名称列表
    }

    /**
     * 根据教师ID获取该教师所管理的班级信息，用于组合框
     * @param teacherId 教师ID
     * @return 该教师管理的班级ID和名称列表
     */
    public List<Map<String, Object>> getTeacherClassesForCombo(int teacherId) {
        List<Map<String, Object>> classes = new ArrayList<>(); // 创建一个ArrayList来存储班级ID和名称
        // SQL查询语句，用于从classes表和subject_teachers表中获取指定教师所管理的班级ID和名称，并按班级名称排序
        String sql = "SELECT c.id, c.class_name FROM classes c " +
                "JOIN subject_teachers st ON c.id = st.class_id " +
                "WHERE st.teacher_id = ? " +
                "GROUP BY c.id, c.class_name " +
                "ORDER BY c.class_name";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL查询

            pstmt.setInt(1, teacherId); // 设置教师ID以指定要查询的教师
            ResultSet rs = pstmt.executeQuery(); // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Map<String, Object> cls = new HashMap<>(); // 创建一个新的HashMap来存储班级ID和名称
                // 设置HashMap对象的各个属性
                cls.put("id", rs.getInt("id")); // 设置班级ID
                cls.put("className", rs.getString("class_name")); // 设置班级名称
                classes.add(cls); // 将HashMap对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return classes; // 返回班级ID和名称列表
    }

    /**
     * 添加一个新的班级
     * @param code 班级代码（注意与classId区分，此参数在实际代码中未使用）
     * @param name 班级名称
     * @param majorCode 专业代码
     * @param grade 年级（注意与gradeYear区分，此参数在实际代码中未使用）
     * @return 如果成功添加，则返回true；否则返回false
     */
    public boolean addClass(String code, String name, String majorCode, String grade) {
        // SQL插入语句，用于向classes表中插入新的班级信息
        String sql = "INSERT INTO classes (class_name, grade_year, major_code, created_at) " +
                "VALUES (?, ?, ?, CURRENT_TIMESTAMP)";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL插入

            // 设置插入语句中的参数
            pstmt.setString(1, name); // 设置班级名称
            pstmt.setString(2, grade); // 设置年级（注意：grade应为int类型，这里使用了String类型）
            pstmt.setString(3, majorCode); // 设置专业代码

            return pstmt.executeUpdate() > 0; // 执行插入操作，如果影响行数大于0，则表示添加成功，返回true
        } catch (SQLException e) { // 捕获SQL异常
            if (e.getErrorCode() == 1062) { // 如果错误代码为1062，表示班级名称已存在
                JOptionPane.showMessageDialog(null, "班级名称已存在！"); // 弹出对话框提示用户
            }
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 添加失败返回false
        }
    }

    /**
     * 获取所有专业的信息
     * @return 所有专业的代码和名称列表
     */
    public List<Map<String, Object>> getAllMajors() {
        List<Map<String, Object>> majors = new ArrayList<>(); // 创建一个ArrayList来存储专业信息
        // SQL查询语句，用于从majors表中获取所有专业的代码和名称
        String sql = "SELECT major_code, major_name FROM majors";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             Statement stmt = conn.createStatement(); // 创建Statement对象执行SQL查询
             ResultSet rs = stmt.executeQuery(sql)) { // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Map<String, Object> major = new HashMap<>(); // 创建一个新的HashMap来存储专业信息
                // 设置HashMap对象的各个属性
                major.put("majorCode", rs.getString("major_code")); // 设置专业代码
                major.put("majorName", rs.getString("major_name")); // 设置专业名称
                majors.add(major); // 将HashMap对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return majors; // 返回专业信息列表
    }

    /**
     * 获取所有可用教师的信息
     * @return 所有教师的ID和名称列表
     */
    public List<Map<String, Object>> getAvailableTeachers() {
        List<Map<String, Object>> teachers = new ArrayList<>(); // 创建一个ArrayList来存储教师信息
        // SQL查询语句，用于从users表中获取所有角色为'TEACHER'的用户信息
        String sql = "SELECT id, name FROM users WHERE role = 'TEACHER'";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             Statement stmt = conn.createStatement(); // 创建Statement对象执行SQL查询
             ResultSet rs = stmt.executeQuery(sql)) { // 执行查询并获取结果集

            while (rs.next()) { // 遍历结果集中的每一行
                Map<String, Object> teacher = new HashMap<>(); // 创建一个新的HashMap来存储教师信息
                // 设置HashMap对象的各个属性
                teacher.put("id", rs.getInt("id")); // 设置教师ID
                teacher.put("name", rs.getString("name")); // 设置教师姓名
                teachers.add(teacher); // 将HashMap对象添加到列表中
            }
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
        }
        return teachers; // 返回教师信息列表
    }

    /**
     * 分配教师到指定班级的指定课程
     * @param classId 班级ID
     * @param subjectName 课程名称
     * @param teacherId 教师ID
     * @return 如果分配成功，则返回true；否则返回false
     */
    public boolean assignTeacher(int classId, String subjectName, int teacherId) {
        // SQL更新语句，用于更新class_subjects表中的教师ID以指定教师到指定班级的指定课程
        String sql = "UPDATE class_subjects SET teacher_id = ? " +
                "WHERE class_id = ? AND subject_id = " +
                "(SELECT id FROM subjects WHERE subject_name = ?)";

        try (Connection conn = DatabaseUtil.getConnection(); // 获取数据库连接
             PreparedStatement pstmt = conn.prepareStatement(sql)) { // 创建PreparedStatement对象执行SQL更新

            // 设置更新语句中的参数
            pstmt.setInt(1, teacherId); // 设置教师ID
            pstmt.setInt(2, classId); // 设置班级ID
            pstmt.setString(3, subjectName); // 设置课程名称

            return pstmt.executeUpdate() > 0; // 执行更新操作，如果影响行数大于0，则表示分配成功，返回true
        } catch (SQLException e) { // 捕获SQL异常
            e.printStackTrace(); // 打印异常堆栈信息
            return false; // 分配失败返回false
        }
    }
}
